Angular Templates: ngTemplateOutlet

[ngTemplateOutlet] உடன் மீண்டும் பயன்படுத்தக்கூடிய டெம்ப்ளேட்டுகளை மறுவழங்கவும்

ngTemplateOutlet என்றால் என்ன?

<ng-template> மீண்டும் பயன்படுத்தக்கூடிய டெம்ப்ளேட் தொகுதியை வரையறுக்கிறது (ஒரு "செய்முறை").

[ngTemplateOutlet] உடன் அதை மறுவழங்கவும்.

[ngTemplateOutletContext] மூலம் மதிப்புகளை அனுப்பவும் மற்றும் let- மாறிகள் மூலம் படிக்கவும்.

டெம்ப்ளேட் அடிப்படைகள்

<ng-template> என்பது ஒரு கோப்பு வரைவு போன்றது - இது ஒரு திட்டமாகும் ஆனால் பயன்படுத்தப்படும் வரை காட்சியில் இல்லை.

[ngTemplateOutlet] அந்த திட்டத்தை உண்மையான காட்சியாக மாற்றுகிறது.

ngTemplateOutlet எப்போது பயன்படுத்த வேண்டும்

முக்கிய உதவிக்குறிப்பு

<ng-container> ஒரு தர்க்கரீதியான மூடியாகப் பயன்படுத்தவும், இது கூடுதல் DOM உறுப்புகளைச் சேர்க்காது.

தொடர்புடையது: உள்ளடக்கத் திட்டத்திற்கான கூறுகளை <ng-content> உடன் பார்க்கவும்.

ng-template vs Component - எது எப்போது?

Use ng-template When:

  • காட்சி மட்டத்தில் மீண்டும் பயன்படுத்த
  • எளிய மறுவழங்கல் மாறுபாடுகள்
  • இலகுவான மறுபயன்பாடு
  • தனி தர்க்கம் தேவையில்லை
  • வெவ்வேறு தரவு உள்ளீடுகள்

Use Component When:

  • மறைக்கப்பட்ட/சுயாதீனமான தர்க்கம்
  • தனி நிலை மேலாண்மை
  • சிக்கலான மறுபயன்பாடு
  • சுய வடிவமைப்பு மற்றும் பாணிகள்
  • உள்ளீடுகள்/வெளியீடுகள் தேவை

Info Template

நீல நிற தகவல் செய்திகள்

<ng-template #infoTpl>
  <p style="color:royalblue">{{ text }}</p>
</ng-template>

Warning Template

ஆரஞ்சு எச்சரிக்கை செய்திகள்

<ng-template #warnTpl>
  <p style="color:darkorange">{{ text }}</p>
</ng-template>

Success Template

பச்சை வெற்றி செய்திகள்

<ng-template #successTpl>
  <p style="color:seagreen">{{ text }}</p>
</ng-template>

Complete Example

Angular ngTemplateOutlet Example

import { bootstrapApplication } from '@angular/platform-browser';
import { Component } from '@angular/core';
import { CommonModule } from '@angular/common';

@Component({
  selector: 'app-root',
  standalone: true,
  imports: [CommonModule],
  template: `
    <h3>Templates with ngTemplateOutlet</h3>

    <label>
      Type:
      <select (change)="type = $any($event.target).value">
        <option value="info">info</option>
        <option value="warning">warning</option>
        <option value="success">success</option>
      </select>
    </label>

    <label>
      Message: <input (input)="msg = $any($event.target).value" [value]="msg" />
    </label>

    <ng-container
      [ngTemplateOutlet]="type === 'info' ? infoTpl : 
                         (type === 'warning' ? warnTpl : successTpl)"
      [ngTemplateOutletContext]="{ $implicit: msg }">
    </ng-container>

    <ng-template #infoTpl let-text>
      <p style="color:royalblue">Info: {{ text }}</p>
    </ng-template>

    <ng-template #warnTpl let-text>
      <p style="color:darkorange">Warning: {{ text }}</p>
    </ng-template>

    <ng-template #successTpl let-text>
      <p style="color:seagreen">Success: {{ text }}</p>
    </ng-template>
  `
})
export class App {
  type: 'info' | 'warning' | 'success' = 'info';
  msg = 'Hello';
}

bootstrapApplication(App);

Example Explained

<ng-template>: மீண்டும் பயன்படுத்தக்கூடிய டெம்ப்ளேட் தொகுதியை வரையறுக்கிறது (குறிப்பிடப்படும் வரை மறுவழங்கப்படாது).

[ngTemplateOutlet]: எந்த டெம்ப்ளேட்டை மறுவழங்குவது என்பதைத் தேர்ந்தெடுக்கிறது (இங்கே வகையின் அடிப்படையில் மூன்று கூறு வெளிப்பாடு மூலம்).

[ngTemplateOutletContext]: டெம்ப்ளேட்டுக்குள் மதிப்புகளை அனுப்புகிறது. $implicit விசை பொருந்தக்கூடிய let- மாறியால் படிக்கப்படுகிறது.

let-text: கண்ணோட்டத்திலிருந்து $implicit மதிப்பைப் படிக்கும் டெம்ப்ளேட்டுக்குள் உள்ளூர் மாறியை அறிவிக்கிறது.

<ng-container>: கூடுதல் DOM உறுப்புகளை உருவாக்காத தர்க்கரீதியான மூடி.

டெம்ப்ளேட் கண்ணோட்டம் மற்றும் மாறிகள்

Context Passing

[ngTemplateOutletContext]="{
  $implicit: 'Hello',
  count: 42,
  active: true
}"

$implicit: let- மாறி இல்லாமல் அணுகக்கூடிய இயல்புநிலை மதிப்பு

Variable Reading

<ng-template #myTemplate 
              let-data 
              let-cnt="count"
              let-isActive="active">
  {{ data }}, {{ cnt }}, {{ isActive }}
</ng-template>

let-data: $implicit ஐப் பெறுகிறது

let-cnt: "count" பண்பைப் பெறுகிறது

டெம்ப்ளேட் கண்ணோட்ட பாய்வு:

Template Definition → ngTemplateOutlet → Context Passing → Variable Reading → Rendering
       ↓                     ↓                 ↓                ↓               ↓
   <ng-template>      [ngTemplateOutlet]   Context Object    let-vars      Final View

நடைமுறை பயன்பாட்டு நிகழ்வுகள்

Dynamic Card Layouts

ஒரே டெம்ப்ளேட்டுடன் வெவ்வேறு தரவு வடிவங்களுக்கான அட்டைகள்

<ng-container *ngFor="let item of items"
               [ngTemplateOutlet]="cardTemplate"
               [ngTemplateOutletContext]="{$implicit: item}">
</ng-container>

Conditional UI Rendering

நிலை அடிப்படையில் வெவ்வேறு UI பகுதிகளை மறுவழங்குதல்

<ng-container [ngTemplateOutlet]="
    user.isAdmin ? adminTpl : userTpl">
</ng-container>

Reusable Table Rows

வெவ்வேறு அட்டவணைகளுக்கு ஒரே வரிசை வடிவமைப்பு

<tr *ngFor="let row of data"
    [ngTemplateOutlet]="rowTemplate"
    [ngTemplateOutletContext]="{row: row}">
</tr>

Exercise

ngTemplateOutlet என்ன செய்கிறது?

ngTemplateOutlet என்ன செய்கிறது?

ஒரு குறிப்பிட்ட இடத்தில் <ng-template> ஐ மறுவழங்குகிறது
✓ சரி! [ngTemplateOutlet] ஒரு குறிப்பிடப்பட்ட <ng-template> ஐ DOM இல் ஒரு குறிப்பிட்ட இடத்தில் மறுவழங்குகிறது
புதிய கூறை மாறும் வகையில் உருவாக்குகிறது
✗ தவறு! ngTemplateOutlet கூறுகளை உருவாக்காது - அது டெம்ப்ளேட்டுகளை மட்டுமே மறுவழங்குகிறது
ஒரு குழாயை வரையறுக்கிறது
✗ தவறு! குழாய்கள் தனி நோக்கங்களுக்காக உள்ளன - ngTemplateOutlet டெம்ப்ளேட் மறுவழங்கலுக்கு பயன்படுகிறது

ngTemplateOutlet சிறந்த நடைமுறைகள்

Use ng-container as Wrapper

கூடுதல் DOM உறுப்புகளைத் தவிர்க்க ng-container உடன் ngTemplateOutlet ஐ இணைக்கவும்

Clear Context Structure

$implicit மற்றும் தெளிவான பண்புப் பெயர்களைக் கொண்ட நன்கு கட்டமைக்கப்பட்ட கண்ணோட்டத்தைப் பயன்படுத்தவும்

Avoid Complex Logic in Outlet

ngTemplateOutlet வெளிப்பாட்டில் மிகவும் சிக்கலான தர்க்கத்தை வைக்காதீர்கள் - கூறு தர்க்கத்தைப் பயன்படுத்தவும்

Common Mistakes

  • மறந்து விடுதல் <ng-container>: ngTemplateOutlet ஐ நேரடியாக div உடன் இணைக்காமல்
  • தவறான கண்ணோட்ட மேப்பிங்: let- மாறிகள் கண்ணோட்ட பண்புகளுடன் பொருந்தவில்லை
  • தேவையில்லாதபோது பயன்படுத்துதல்: எளிய *ngIf அல்லது *ngFor போதுமானதாக இருக்கும்போது ngTemplateOutlet பயன்படுத்துதல்
அடுத்தது